// 认证服务 - 处理用户登录、注册等认证相关操作
import axios from 'axios'

// 创建axios实例用于认证服务
const authApiClient = axios.create({
  baseURL: '/api', // 使用相对路径，通过代理访问后端
  timeout: 10000,
  headers: {
    'Content-Type': 'application/json'
  }
})

// 存储键名常量
const STORAGE_KEYS = {
  USERS: 'mental_health_users',
  CURRENT_USER: 'user',
  TOKEN: 'token',
  REFRESH_TOKEN: 'refreshToken'
}

// 从LocalStorage获取用户列表
function getUsers() {
  const users = localStorage.getItem(STORAGE_KEYS.USERS)
  return users ? JSON.parse(users) : []
}

// 保存用户列表到LocalStorage
function saveUsers(users) {
  localStorage.setItem(STORAGE_KEYS.USERS, JSON.stringify(users))
}

// 模拟密码加密（简单实现）
function encryptPassword(password) {
  return btoa(password) // 简单的Base64编码，实际项目应使用更安全的加密方式
}

// 验证密码
function verifyPassword(plainPassword, encryptedPassword) {
  return btoa(plainPassword) === encryptedPassword
}

// 生成唯一ID
function generateId() {
  return Date.now().toString(36) + Math.random().toString(36).substr(2)
}

// 生成JWT令牌（模拟）
function generateToken(userId) {
  return `token_${userId}_${Date.now()}_${Math.random().toString(36).substr(2)}`
}

// 请求拦截器 - 为认证相关请求添加token
authApiClient.interceptors.request.use(
  config => {
    // 只有不是登录、注册相关的接口才添加token
    if (!config.url.includes('/auth/login/') && !config.url.includes('/auth/register/') && !config.url.includes('/auth/reset-password')) {
      const token = localStorage.getItem('token')
      if (token) {
        config.headers.Authorization = `Bearer ${token}`
      }
    }
    return config
  },
  error => {
    return Promise.reject(error)
  }
)

// 响应拦截器
authApiClient.interceptors.response.use(
  response => {
    return response.data // 直接返回响应数据
  },
  error => {
    // 更详细的错误信息提取和日志记录
    const errorDetails = {
      url: error.config?.url,
      method: error.config?.method,
      status: error.response?.status,
      statusText: error.response?.statusText,
      data: error.response?.data,
      message: error.message
    };
    
    // 根据错误状态提供更友好的错误信息
    let userFriendlyMessage = '请求失败';
    
    if (error.response) {
      switch (error.response.status) {
        case 400:
          userFriendlyMessage = error.response.data?.msg || '请求参数错误，请检查输入';
          break;
        case 401:
          userFriendlyMessage = error.response.data?.msg || '未授权，请重新登录';
          break;
        case 403:
          userFriendlyMessage = error.response.data?.msg || '权限不足';
          break;
        case 404:
          userFriendlyMessage = error.response.data?.msg || '请求的资源不存在';
          break;
        case 500:
          userFriendlyMessage = error.response.data?.msg || '服务器内部错误，请稍后重试';
          break;
        default:
          userFriendlyMessage = error.response.data?.msg || `请求失败 (${error.response.status})`;
      }
    } else if (error.request) {
      // 请求已发出但没有收到响应
      userFriendlyMessage = '网络异常，请检查您的网络连接';
    }
    
    console.error('认证API请求错误:', JSON.stringify(errorDetails, null, 2));
    throw new Error(userFriendlyMessage);
  }
)

class AuthService {
  constructor() {
    this.apiClient = authApiClient
  }

  // 通用请求方法
  async request(endpoint, options = {}) {
    try {
      const response = await this.apiClient(endpoint, options)
      return response
    } catch (error) {
      console.error('认证API请求失败:', error)
      throw error
    }
  }

  // 手机号+密码登录
  async loginWithPassword(phone, password) {
    try {
      // 尝试调用实际API进行登录
      console.log('尝试通过后端API登录');
      const response = await this.request({
        url: '/v1/auth/login/password',
        method: 'POST',
        data: { phone, password }
      });
      return response;
    } catch (error) {
      console.log('后端API暂时不可用，使用本地存储模拟登录');
      
      // 从本地存储获取用户列表
      const users = getUsers();
      
      // 查找用户
      const user = users.find(u => u.phone === phone);
      if (!user) {
        throw new Error('用户不存在，请先注册');
      }
      
      // 验证密码
      if (!verifyPassword(password, user.password)) {
        throw new Error('密码错误，请重新输入');
      }
      
      // 生成令牌
      const token = generateToken(user.id);
      const refreshToken = `refresh_${token}`;
      
      // 构造响应数据
      const response = {
        token,
        refreshToken,
        user: {
          id: user.id,
          phone: user.phone,
          nickname: user.nickname || `用户${phone.slice(-4)}`,
          expireTime: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString() // 7天后过期
        }
      };
      
      // 保存登录状态
      this.saveLoginState(response);
      
      console.log('本地模拟登录成功');
      return response;
    }
  }

  // 注册
  async register(phone, password, username = '') {
    try {
      // 尝试调用实际API进行注册
      console.log('尝试通过后端API注册');
      const response = await this.request({
        url: '/v1/auth/register/submit',
        method: 'POST',
        data: { phone, password, username }
      });
      return response;
    } catch (error) {
      console.log('后端API暂时不可用，使用本地存储模拟注册');
      
      // 从本地存储获取用户列表
      const users = getUsers();
      
      // 检查用户是否已存在
      if (users.some(u => u.phone === phone)) {
        throw new Error('该手机号已注册，请直接登录');
      }
      
      // 创建新用户
      const newUser = {
        id: generateId(),
        phone,
        password: encryptPassword(password),
        nickname: username || `用户${phone.slice(-4)}`,
        createTime: new Date().toISOString()
      };
      
      // 保存用户
      users.push(newUser);
      saveUsers(users);
      
      // 生成令牌
      const token = generateToken(newUser.id);
      const refreshToken = `refresh_${token}`;
      
      // 构造响应数据
      const response = {
        token,
        refreshToken,
        user: {
          id: newUser.id,
          phone: newUser.phone,
          nickname: newUser.nickname,
          expireTime: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString() // 7天后过期
        }
      };
      
      // 保存登录状态
      this.saveLoginState(response);
      
      console.log('本地模拟注册成功');
      return response;
    }
  }

  // 刷新令牌
  async refreshToken() {
    const oldToken = localStorage.getItem('refreshToken') || localStorage.getItem('token')
    return this.request({
      url: '/v1/user/auth/refresh-token',
      method: 'POST',
      data: { oldToken }
    });
  }

  // 退出登录
  async logout() {
    try {
      // 调用后端退出登录接口
      await this.request({
        url: '/v1/user/auth/logout',
        method: 'POST'
      });
    } catch (error) {
      console.error('退出登录失败:', error);
      // 即使失败也清除本地数据
    } finally {
      // 清除本地存储的令牌和用户信息
      localStorage.removeItem('token');
      localStorage.removeItem('refreshToken');
      localStorage.removeItem('user');
      localStorage.removeItem('privacySettings');
      localStorage.removeItem('diaryEntries');
    }
  }

  // 忘记密码
  async resetPassword(phone, code, newPassword) {
    return this.request({
      url: '/v1/auth/reset-password',
      method: 'POST',
      data: { phone, code, newPassword }
    });
  }

  // 保存登录状态
  saveLoginState(response) {
    // 简化的登录状态保存逻辑
    const data = response.data || response;
    
    // 保存token和refreshToken
    if (data.token) {
      localStorage.setItem('token', data.token);
    }
    if (data.refreshToken) {
      localStorage.setItem('refreshToken', data.refreshToken);
    }
    
    // 保存用户信息
    if (data.user && typeof data.user === 'object') {
      localStorage.setItem('user', JSON.stringify(data.user));
    }
  }

  // 获取当前登录用户
  getCurrentUser() {
    const userStr = localStorage.getItem('user');
    return userStr ? JSON.parse(userStr) : null;
  }

  // 检查是否已登录
  isAuthenticated() {
    const token = localStorage.getItem('token');
    return !!token && !this.isTokenExpired(token);
  }

  // 检查token是否过期（简单实现，实际应解析JWT）
  isTokenExpired(token) {
    try {
      const user = this.getCurrentUser();
      if (user && user.expireTime) {
        const expireTime = new Date(user.expireTime).getTime();
        return expireTime < Date.now();
      }
      return false;
    } catch (error) {
      return false;
    }
  }

  // 获取认证令牌
  getToken() {
    return localStorage.getItem('token');
  }

  // 获取刷新令牌
  getRefreshToken() {
    return localStorage.getItem('refreshToken');
  }

  // 更新用户信息
  updateUserInfo(userInfo) {
    const currentUser = this.getCurrentUser();
    const updatedUser = { ...currentUser, ...userInfo };
    localStorage.setItem('user', JSON.stringify(updatedUser));
    return updatedUser;
  }
}

// 导出单例实例
const authService = new AuthService();
export default authService;